1. Field of the Invention
The present invention relates generally to accessing buffer objects in GPU memory and, more specifically, to global stores and atomic operations.
2. Description of the Related Art
Graphics languages have evolved in a way that allows an application to replace many of the original state machine variables with blocks of user-defined data. For example, the current vertex state has been augmented by vertex buffer objects, fixed-function shading state and parameters have been replaced by shaders/programs and constant buffer objects. Applications switch between coarse sets of state by binding buffer objects to the application context or to other container objects (e.g. vertex array objects) instead of manipulating state variables of the application context.
A typical graphics pipeline includes several shader stages, and each shader stage executes commands specified by the application on data stored in buffer objects bound to the application context. For example, when preparing for a typical graphics pipeline rendering command, an application binds a buffer name associated with a buffer object to the application context, and, in response, a graphics driver looks up the buffer object based on the buffer object name. The application then specifies a set of vertex attributes for the primitives to be rendered, which will be used as inputs to the vertex shader stage, and the graphics driver attaches the buffer object to those vertex attributes. Once the application issues a draw command, the graphics driver locks the buffer object in memory and transmits the draw command and the physical address of the buffer object to the GPU for processing. In such an implementation, the graphics driver tracks the usage of the buffer object and unlocks the buffer object once the buffer object is no longer in use.
One drawback to the current usage of buffer objects is that the graphics driver is responsible for keeping track of buffer objects and determining the physical addresses of buffer objects based on the corresponding buffer names. This results in a graphics driver bottleneck involving pointer chases and L2 cache misses that affects the overall performance of a graphics system. Another drawback to the current usage of buffer objects is that data cannot be written back to the buffer objects from within the different shader stages, thus limiting the flexibility available to programmers when programming subsequent shading stages.
As the foregoing illustrates, what is needed in the art is a mechanism for accessing buffer objects and storing data to buffer objects without causing a graphics driver bottleneck.